home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / Venus / SimpleWindow.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-26  |  8.5 KB  |  330 lines  |  [TEXT/ALFA]
  1. /*
  2.  ***********************************************************************
  3.  *
  4.  *
  5.  *                                Simple Window Class
  6.  *        
  7.  *
  8.  ***********************************************************************
  9.  */
  10.  
  11. #include "image.h"
  12. #include "window.h"
  13. #include <PictUtil.h>
  14.  
  15. /*
  16.  *----------------------------------------------------------------------
  17.  *                            Service functions
  18.  */
  19.  
  20.                                         // Getting a bounding rectangle of an image
  21. ScreenRect::ScreenRect(const IMAGE& image)
  22. {
  23.     top = 0;
  24.     bottom = top + image.q_nrows();
  25.     left = 0;
  26.     right = left + image.q_ncols();
  27. }
  28.  
  29.                                     // Create a rectangle of given height/width
  30.                                     // positioned at the origin
  31. ScreenRect::ScreenRect(const rowcol& heightwidth)
  32. {
  33.     left = top = 0;
  34.     bottom = heightwidth.row();
  35.     right  = heightwidth.col();
  36. }
  37.  
  38.                                     // Create a rectangle of given height/width
  39.                                     // positioned at a given point
  40. ScreenRect::ScreenRect(const rowcol& origin, const rowcol& heightwidth)
  41. {
  42.     top  = origin.row();
  43.     left = origin.col();
  44.     bottom = top+heightwidth.row();
  45.     right  = left+heightwidth.col();
  46. }
  47.  
  48.  
  49.                                     // Shifting a rectangle by the same amount
  50.                                     // in X and Y
  51. ScreenRect& ScreenRect::operator += (const int offset)
  52. { 
  53.     top += offset; bottom += offset; left += offset; right += offset;
  54.     return *this;
  55. }
  56.  
  57.  
  58.                                     // Print what rectangle is this
  59. void ScreenRect::print(const char * title) const
  60. {
  61.     message("Rectangle %s (%d,%d) - (%d,%d)",title,top,left,bottom,right);
  62. }
  63.  
  64.  
  65.  
  66.                                     // Used to "implicitly" convert from C to Pascal
  67.                                     // string
  68. Pstr::Pstr(const char * c_str)
  69. {
  70.     strncpy((char *)pas_string,c_str,sizeof(*this)-2);
  71.     CtoPstr((char *)pas_string);
  72. }
  73.  
  74. /*
  75.  *----------------------------------------------------------------------
  76.  *        A generic simple window that can be dragged around the screen
  77.  *                and closed by clicking a "go-away" button
  78.  * No other events are handled, redefine the event handler if necessary.
  79.  */
  80.  
  81.  
  82.                                     // Create a color window of the specified size and title
  83.                                     // Note, the upper left corner of 'rect' must
  84.                                     // NOT be (0,0)!
  85. ScreenWindow::ScreenWindow(ScreenRect rect, const char * title)
  86. {
  87.     const int window_offset = 100;        // Cannot be 0 or small!
  88.     this_window = NewCWindow(nil,rect += window_offset,(Pstr)title,
  89.                             TRUE,noGrowDocProc,
  90.                             (WindowPtr)(-1),TRUE,(long)this);
  91.     assert( this_window != 0 );
  92.     SetPort(this_window);
  93.     SelectWindow(this_window);
  94. }
  95.  
  96.                                     // Create a color window from a resource template
  97. ScreenWindow::ScreenWindow(const short resource_id)
  98. {
  99.     this_window = GetNewCWindow(resource_id,nil,(WindowPtr)(-1));
  100.     SetWRefCon(this_window,(long)this);
  101.     assert( this_window != 0 );
  102.     SetPort(this_window);
  103.     SelectWindow(this_window);
  104. }
  105.  
  106.  
  107.  
  108.                                     // Close the window and clean up the rubble
  109. ScreenWindow::~ScreenWindow(void)
  110. {
  111.     assert( this_window != 0 );
  112.     DisposeWindow(this_window);
  113.     this_window = 0;
  114. }
  115.  
  116.  
  117.                                     // Event handling loop. Returns only when the
  118.                                     // window is to be destroyed
  119. void ScreenWindow::handle(void)
  120. {
  121.     const long event_timeout = 20;
  122.     EventRecord    theEvent;
  123.  
  124.     for(;;)
  125.     {
  126.         if( !WaitNextEvent(everyEvent, &theEvent,event_timeout,nil) )
  127.           if( handle_null_event(theEvent.when) )
  128.             continue;
  129.           else
  130.             return;
  131.           switch (theEvent.what)
  132.         {
  133.           case mouseDown:
  134.             if( !handle_mouse_down(theEvent) )
  135.               return;                        // Window is to be closed (go-away buttin clicked)
  136.             break;
  137.             
  138.           case updateEvt:
  139.             if( this_window == (WindowPtr)theEvent.message )
  140.               update();
  141.             break;
  142.  
  143.           case keyDown:
  144.           case autoKey:
  145.             if( !handle_key_down(theEvent) )
  146.               return;                        // a "quit" key must've been pressed
  147.             break;
  148.                         
  149.           case activateEvt:
  150.             if( this_window == (WindowPtr)theEvent.message )
  151.               activate(theEvent.modifiers & 0x01);
  152.             break;
  153.         }  
  154.     }
  155.     
  156. }
  157.  
  158.                                 // Handle "mouse-down" events
  159.                                 // Returns FALSE if the user clicked within the
  160.                                 // go-away region of our window. Otherwise,
  161.                                 // returns TRUE
  162.                                 // Handles dragging if necessary and system clicks
  163. Boolean ScreenWindow::handle_mouse_down(const EventRecord& the_event)
  164. {
  165.     WindowPtr    wp;
  166.     short        windowPart = FindWindow (the_event.where, &wp);
  167.     
  168.     switch (windowPart)
  169.     {
  170.       case inSysWindow: 
  171.         SystemClick(&the_event, wp);
  172.         break;
  173.         
  174.       case inMenuBar:
  175.         break;
  176.  
  177.       case inContent:
  178.           break;
  179.           
  180.       case inDrag:
  181.           if (wp == this_window )
  182.             drag(the_event.where);
  183.           break;
  184.                       
  185.       case inGoAway:
  186.           return FALSE;
  187.     }
  188.     return TRUE;
  189. }
  190.  
  191.                                         // Handles key_down & auto_key events. Return FALSE
  192.                                         // if the window is to be closed down
  193. Boolean ScreenWindow::handle_key_down(const EventRecord& the_event)
  194. {
  195.     return FALSE;                        // Each key kills the application, sorry
  196. }
  197.  
  198.  
  199.                                         // Handles null events, when nothing happens for some
  200.                                         // time. Return FALSE when it's time to die
  201. Boolean ScreenWindow::handle_null_event(const long event_time)
  202. {
  203.     return TRUE;                            // Keep going
  204. }
  205.  
  206.                             // Private window parts
  207.                                     // Handle an update event - redraw the window
  208.                                     // A virtual function draw() is called to do
  209.                                     // the actual redrawing
  210. void ScreenWindow::update(void)
  211. {
  212.     GrafPtr    savePort;
  213.     
  214.     GetPort(&savePort);
  215.     SetPort(this_window);
  216.     BeginUpdate(this_window);
  217.     draw();
  218.     EndUpdate(this_window);
  219.     SetPort(savePort);
  220. }
  221.  
  222.                                     // Make the entire window being redrawn
  223. void ScreenWindow::refresh(void)
  224. {
  225. //    EraseRect(&this_window->portRect);
  226.     InvalRect(&this_window->portRect);            
  227. }
  228.  
  229.                                         // Handle an activate or deactivate event
  230. void ScreenWindow::activate (const Boolean go_active)
  231. {
  232.     if (go_active)
  233.       SetPort(this_window);
  234. }
  235.  
  236.  
  237. /*
  238.  *----------------------------------------------------------------------
  239.  *            A simple window with an offscreen window buffer
  240.  */
  241.  
  242.                                 // Allocate the buffer for the offscreen
  243.                                 // drawing and load CLUT (if clut_id != 0)
  244. OffScreenWindow::OffScreenWindow
  245.     (ScreenRect rect, const char * title, const short clut_id)
  246.     : ScreenWindow(rect,title), graf_world(nil)
  247. {
  248.     CTabHandle clut_handle = nil;
  249.     if( clut_id != 0 )
  250.     {                                // try to get a user CLUT with that resource id
  251.        clut_handle = GetCTable(clut_id);
  252.        assert( clut_handle != 0 );
  253.        SetWinColor(our_window(),(WinCTab**)clut_handle);
  254.     }
  255.     do_well( NewGWorld(&graf_world,8,rect,clut_handle,nil,0) );
  256.     assert( graf_world != (void *)0 );
  257.  
  258. //    if( clut_handle != nil )
  259. //      DisposCTable(clut_handle);        // CLUT has been copied, and can be disposed of now
  260.                                         // But careful! CLUT is associated with the window
  261.                                         // by SetWinColor(), so we don't dispose of it
  262.  
  263.                                         // Get hold of the offscreen pixmap
  264.     pixmap = GetGWorldPixMap(graf_world);        // and make sure it looks like
  265.     assert( pixmap != nil && *pixmap != nil );    // we can use it
  266.  
  267.     assert( (**pixmap).cmpCount == 1 );            // We have a color table index
  268.     assert( !PixMap32Bit(pixmap) );
  269.  
  270.     _height = abs((**pixmap).bounds.top - (**pixmap).bounds.bottom);
  271.     _width  = abs((**pixmap).bounds.right - (**pixmap).bounds.left);
  272.     _bytes_per_row = (**pixmap).rowBytes & 0x7fff;
  273.  
  274.     assert( _height > 0 && _height < 10000 );         // Just to play safe
  275.     assert( _width > 0 && _width <= _bytes_per_row );    
  276.  
  277.     activate_palette();                    // Activate palette for the window
  278. }
  279.  
  280.                                 // Dispose of the offscreen buffer
  281. OffScreenWindow::~OffScreenWindow(void)
  282. {
  283.     assert( graf_world != nil );
  284.     DisposeGWorld(graf_world);
  285.     graf_world = nil;
  286.     PaletteHandle window_palette = GetPalette(our_window());
  287.     if( window_palette != nil )                // dispose of our palette if was allocated
  288.     {
  289.         SetPalette(our_window(),nil,FALSE);
  290.         DisposePalette(window_palette);
  291.     }
  292.     pixmap = nil;
  293.     _height = _width = _bytes_per_row = 0;
  294. }
  295.  
  296.                                     // Make sure that the colors of our off-screen
  297.                                     // buffer would be displayed properly (or close enough)
  298.                                     // on screen
  299. void OffScreenWindow::activate_palette(void)
  300. {
  301.     CTabHandle window_ctab = (**pixmap).pmTable;
  302.     assert( window_ctab != nil && *window_ctab != nil );
  303.  
  304.     PaletteHandle palette = NewPalette((**window_ctab).ctSize,window_ctab,pmTolerant+pmExplicit,0);
  305.     assert( palette != nil );
  306.     SetPalette(our_window(),palette,TRUE);
  307.     do_well( QDError() );
  308.     ActivatePalette(our_window());    
  309.     do_well( QDError() );
  310. }
  311.  
  312.  
  313.                                 // Get a bounding rectangle for the window
  314. ScreenRect OffScreenWindow::q_bounds(void) const
  315. {
  316.     return (**pixmap).bounds;
  317. }
  318.  
  319.  
  320.                                     // Actual drawing - moving the picture from the
  321.                                     // offscreen grafworld to the onscreen one
  322. void OffScreenWindow::draw(void)
  323. {
  324.     assert( LockPixels(pixmap) );
  325.     Rect& pixmap_rect = (**pixmap).bounds;
  326.     CopyBits((const BitMap *)*pixmap, &thePort->portBits, &pixmap_rect, 
  327.              &our_window()->portRect, /*ditherCopy*/ srcCopy, nil);
  328.     UnlockPixels(pixmap);
  329. }
  330.